// 加载模块
const express = require('express')
const mail = require('../utils/email')
const User = require('../db/models/userModel')

const md5 = require("md5");
const jsonwebtoken = require("jsonwebtoken");
const bodyParser = require("body-parser");
const path = require("path");
const fs = require("fs");
const e = require("express");
const mongoose = require("mongodb")


// 生成路由实例
const router = express.Router()


const secret = fs.readFileSync(path.join(__dirname, "../", ".env"), "utf-8");
// 缓存验证码
let cacheCode = {
        // '23456745@qq.com': 65766,
        // '570062873@qq.com': 20257,
    }
    // *******************************************************************
    // 登录接口
    /**
     * @api {post} /user/login 用户登录
     * @apiGroup user
     * @apiParam {String} mobile 用户账号/手机号
     * @apiParam {String} password 用户密码
   
     *
     * @apiSuccessExample 返回数据示例:
     * {
     *     "err": 0,
     *     "msg": "登录成功"
     * }
     */
    // router.post('/login', (req, res) => {
    //     let { user, pass } = req.body
    //         // 对数据进行校验（空值，格式，长度等）
    //     if (!user || !pass) {
    //         return res.send({ err: -1, msg: '参数错误' })
    //     }

//     // 查询数据
//     User.find({ user, pass })
//         .then((data) => {
//             if (data.length > 0) {
//                 res.send({ err: 0, msg: '登陆成功' })
//             } else {
//                 res.send({ err: -2, msg: '账号或密码错误' })
//             }
//         })
//         .catch((err) => {
//             res.send({ err: -3, msg: '请求出错了，请重试' })
//         })
//         // res.send('login ok')
// })

// 密码加密中间件
const passwdCrypt = (req, res, next) => {
    // 明文密码字段为password
    // 加盐加密或加料加密
    const passwd = md5(req.body.password + md5(req.body.password).substr(9, 17));
    // 将加密的密码挂载到req的body上（覆盖原密码）
    req.body.password = passwd;
    console.log(req.body.password)
        // 继续
    next();
};
// app.use(passwdCrypt);

// 路由
// 接口1：用户登录
router.post("/login", passwdCrypt, (req, res) => {
    // 获取手机号与加密之后的密码
    let data = req.body;
    // console.log(data);
    // 去数据库中去查询上是否存在对应的记录
    // 注意：mongoose提供的方法都是异步的
    User.findOne(data).then((ret) => {
        console.log(ret);
        // findOne：查不到返回null，查到就返回对应的文档（建议）
        // find：查不到返回空数组，查到了返回包括文档的数组
        if (ret) {
            // 查到了，签发令牌
            // 语法：jsonwebtoken.sign(载荷对象,secret)
            // console.log(ret);
            let _token = jsonwebtoken.sign({
                    userId: ret.userId,
                },
                secret
            );
            res.send({
                error: 0,
                msg: "登录成功！",
                _token,
                // _token: "zhangsan " + _token,
            });
        } else {
            // 没查到
            res.send({
                error: 1,
                msg: "手机号或密码错误。",
            });
        }
    });
});

// 接口2：获取用户信息
router.get("/getUserInfo", (req, res) => {
    // 1. 认证token（在认证的过程中，如果认证失败，程序会抛异常）
    try {
        let tokenStr = req.headers["authorization"];
        let arr = tokenStr.split(" ");
        // 最后一个元素即token
        let token = arr[arr.length - 1];
        // 开始验证令牌
        // 语法：jsonwebtoken.verify(令牌字符串,secret)
        // 验证成功返回载荷，验证失败抛异常
        const ret = jsonwebtoken.verify(token, secret);
        // console.log(ret);
        // （可选）验证是否过期【约定过期时间2小时，7200s】
        if (Date.now() / 1000 - ret.iat > 7200) {
            // 过期了
            res.send({
                error: 3,
                msg: "token令牌已经过期。",
                _token: "",
            });
        } else {
            // 没过期
            // 判断是否马上要过期了，如果是自动给它生成新的token
            if (Date.now() / 1000 - ret.iat > 5400) {
                token = jsonwebtoken.sign({
                        mobile: ret.mobile,
                    },
                    secret
                );
            }
            // 获取数据
            User.findOne({ user: ret.user }).then((ret) => {
                // 2. 返回（失败或成功）
                if (ret) {
                    // 取到信息了，则返回
                    console.log(ret)
                    res.send({
                        error: 0,
                        msg: "用户信息获取成功！",
                        _token: token,
                        data: {
                            user: ret.user,
                            // mobile: ret.mobile.substr(0, 3) + "****" + ret.mobile.substr(-4),
                            // mobile: ret.mobile.replace(/(\d{3})\d{4}(\d{4})$/,"$1****$2"),
                            mobile: ret.mobile,
                            // headIcon: ret.headIcon,
                            gender: ret.gender,
                        },
                    });
                } else {
                    // 账号已经已经没了
                    res.send({
                        error: 4,
                        msg: "你号没了。",
                        _token: "",
                    });
                }
            });
        }
    } catch (error) {
        // 抛异常了
        res.status(500).send({
            error: 2,
            msg: "token令牌验证失败。",
        });
    }
});

// 接口3：获取初始的数据库中用户的密码加密结果（一次性接口）
// app.post("/api/v1/user/passwdInit",passwdCrypt, (req, res) => {
//     res.send("您的初始密码为123456，加密结果为：" + req.body.password);
// });

// ******************************************************************
// 注册接口
/**
 * @api {post} /user/register 用户注册
 * @apiGroup user
 *
 * @apiParam {String} user 用户名
 * @apiParam {String} password 用户密码
 * @apiParam {String} email 用户邮箱
 * @apiParam {String} mobile 用户手机号

 * 
 *  
 *
 * @apiSuccessExample 返回数据示例:
 * {
 *     "err": 0,
 *     "msg": "注册成功"
 * }
 */
router.post('/register', passwdCrypt, (req, res) => {
    let { user, password, email, mobile } = req.body
        // 对数据进行校验（空值，邮箱格式，长度等）
    if (!user || !password || !email || !mobile) {
        return res.send({ err: -1, msg: '参数错误' })
    }
    // 校验验证码
    // if (cacheCode[email] != code) {
    //     return res.send({ err: -2, msg: '验证码错误' })
    // }

    // 查询数据库，当前账号是否已注册
    User.find({ mobile })
        .then((data) => {
            if (data.length > 0) {
                res.send({ err: -3, msg: '用户名已存在' })
            } else {
                // 可以注册（插入数据）
                return User.insertMany({ user, password, email, mobile })
            }
        })
        .then((data) => {
            if (data.length > 0) {
                res.send({ err: 0, msg: '注册成功' })
            } else {
                res.send({ err: -4, msg: '注册失败' })
            }
        })
        .catch((err) => {
            res.send({ err: -5, msg: '状态异常，请重试' })
        })
        // res.send('register ok')
})

// 发送邮箱验证码
/**
 * @api {post} /user/sendmail 发送邮箱验证码
 * @apiGroup user
 *
 * @apiParam {String} email 用户邮箱
 *
 * @apiSuccessExample 返回数据示例:
 * {
 *     "err": 0,
 *     "msg": "验证码发送成功"
 * }
 */
router.post('/sendmail', (req, res) => {
    let { email } = req.body
        // 对数据进行校验（空值，邮箱格式等）
    if (!email) {
        return res.send({ err: -1, msg: '参数错误' })
    }

    // 随机验证码
    let code = parseInt(Math.random() * 100000)

    // 发送邮件
    mail.send(email, '验证码', `您的验证码是：${code}`)
        .then(() => {
            // 缓存当前用户的验证码
            cacheCode[email] = code
            res.send({ err: 0, msg: '验证码发送成功' })
        })
        .catch((err) => {
            res.send({ err: -2, msg: '验证码发送失败' })
        })

    // res.send('sendmail ok')
})


/**
 * @api {post} /user/getPage 分页查询
 * @apiGroup user
 *
 * @apiParam {String} page 页码
 * @apiParam {String} size 每页数据条数
 *
 * @apiSuccessExample 返回数据示例:
 * {
 *     "err": 0,
 *     "msg": "查询成功",
 *     "data": [{...},{...}],
 *     "pages": 3,
 *     "count": 10
 * }
 */
router.post('/getPage', (req, res) => {
    let { page, size } = req.body
    page = page || 1 // 页码，默认第一页
    size = size || 4 // 每页条数，默认4条
    let pages = 0 // 数据总页数
    let count = 0 // 数据总条数
        // 查询数据
    User.find()
        .then((data) => {
            count = data.length // 数据总条数
            pages = Math.ceil(count / size) // 数据总页数

            // 查询指定页码的数据
            return User.find().limit(Number(size)).skip(Number((page - 1) * size))
        })
        .then((data) => {
            res.send({ err: 0, msg: '查询成功', data: data, pages: pages, count: count })
        })
        .catch((err) => {
            res.send({ err: -2, msg: '查询失败' })
        })
})




/**
 * @api {post} /user/del 删除用户
 * @apiGroup user
 *
 * @apiParam {String} id 用户id
 *
 * @apiSuccessExample 返回数据示例:
 * {
 *     "err": 0,
 *     "msg": "删除成功"
 * }
 */
router.post('/del', (req, res) => {
    let { mobile } = req.body
        // return res.send({code})
        // 对数据进行校验（空值，格式，长度等）
    if (!mobile) {
        return res.send({ err: -1, msg: '参数错误' })
    }

    User.deleteOne({ mobile })
        .then((data) => {
            res.send({ err: 0, msg: '删除成功' })
        })
        .catch((err) => {
            res.send({ err: -2, msg: '删除失败' })
        })
})


/**
 * @api {post} /user/search 关键字查询
 * @apiGroup user
 *
 * @apiParam {String} kw 关键字
 *
 * @apiSuccessExample 返回数据示例:
 * {
 *     "err": 0,
 *     "msg": "查询成功",
 *     "data": [{...},{...}]
 * }
 */
router.post('/search', (req, res) => {
    let { kw } = req.body
    let reg = new RegExp(kw)
        // 对数据进行校验（空值，格式，长度等）
    if (!kw) {
        return res.send({ err: -1, msg: '参数错误' })
    }

    // 查询数据
    User.find({ $or: [{ user: { $regex: reg } }, { mobile: { $regex: reg } }] })
        .then((data) => {
            if (data.length > 0) {
                res.send({ err: 0, msg: '查询成功', data: data })
            } else {
                res.send({ err: -1, msg: '暂无数据', data: [] })
            }
        })
        .catch((err) => {
            res.send({ err: -2, msg: '查询失败' })
        })
})



module.exports = router